const express = require('express');
const multer = require('multer');
const fs = require('fs');
const path = require('path');
const cors = require('cors');

const app = express();
const PORT = process.env.PORT || 3000;

// 启用CORS
app.use(cors());

// 解析JSON请求体
app.use(express.json());

// 提供静态文件
app.use(express.static(__dirname));

// 配置文件上传
const storage = multer.diskStorage({
  destination: function(req, file, cb) {
    // 根据请求中的类型参数确定存储目录
    const type = req.body.type || 'placeholder';
    const uploadDir = path.join(__dirname, 'img', type);
    
    // 确保目录存在
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }
    
    cb(null, uploadDir);
  },
  filename: function(req, file, cb) {
    // 生成文件名: 时间戳-原始文件名
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    const ext = path.extname(file.originalname);
    cb(null, uniqueSuffix + ext);
  }
});

const upload = multer({ 
  storage: storage,
  limits: {
    fileSize: 5 * 1024 * 1024, // 限制5MB
  },
  fileFilter: function (req, file, cb) {
    // 仅接受图片文件
    if (!file.originalname.match(/\.(jpg|jpeg|png|gif)$/)) {
      return cb(new Error('只允许上传图片文件!'), false);
    }
    cb(null, true);
  }
});

// 读取JSON文件
function readJsonFile(filename) {
  try {
    const filePath = path.join(__dirname, 'data', filename);
    const data = fs.readFileSync(filePath, 'utf8');
    return JSON.parse(data);
  } catch (error) {
    console.error(`读取文件 ${filename} 时出错:`, error);
    return null;
  }
}

// 写入JSON文件
function writeJsonFile(filename, data) {
  try {
    const filePath = path.join(__dirname, 'data', filename);
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
    return true;
  } catch (error) {
    console.error(`写入文件 ${filename} 时出错:`, error);
    return false;
  }
}

// 上传图片接口
app.post('/api/upload', upload.single('image'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ success: false, message: '没有文件被上传' });
    }

    // 构建文件相对路径（用于存储在JSON中）
    const type = req.body.type || 'placeholder';
    const relativePath = `img/${type}/${req.file.filename}`;
    
    return res.json({
      success: true,
      filePath: relativePath,
      originalName: req.file.originalname
    });
  } catch (error) {
    console.error('上传处理出错:', error);
    return res.status(500).json({ success: false, message: '文件上传失败', error: error.message });
  }
});

// 更新相册数据接口
app.post('/api/albums/add', (req, res) => {
  try {
    const albumData = req.body;
    if (!albumData || !albumData.title || !albumData.date || !albumData.category) {
      return res.status(400).json({ success: false, message: '缺少必要的相册信息' });
    }

    // 读取相册数据
    const albums = readJsonFile('albums.json');
    if (!albums) {
      return res.status(500).json({ success: false, message: '无法读取相册数据' });
    }

    // 生成新ID（简单地使用当前最大ID + 1）
    const maxId = Math.max(...albums.albums.map(album => album.id || 0), 0);
    albumData.id = maxId + 1;
    
    // 确保photos属性存在
    if (!albumData.photos) {
      albumData.photos = [];
    }
    
    // 将新相册添加到数据中
    albums.albums.push(albumData);
    
    // 保存更新后的数据
    if (writeJsonFile('albums.json', albums)) {
      return res.json({ success: true, album: albumData });
    } else {
      return res.status(500).json({ success: false, message: '保存相册数据失败' });
    }
  } catch (error) {
    console.error('添加相册出错:', error);
    return res.status(500).json({ success: false, message: '添加相册失败', error: error.message });
  }
});

// 删除相册接口
app.delete('/api/albums/:id', (req, res) => {
  try {
    const albumId = parseInt(req.params.id);
    if (isNaN(albumId)) {
      return res.status(400).json({ success: false, message: '无效的相册ID' });
    }

    // 读取相册数据
    const albums = readJsonFile('albums.json');
    if (!albums) {
      return res.status(500).json({ success: false, message: '无法读取相册数据' });
    }

    // 查找要删除的相册
    const albumIndex = albums.albums.findIndex(album => album.id === albumId);
    if (albumIndex === -1) {
      return res.status(404).json({ success: false, message: '相册不存在' });
    }

    // 获取要删除的相册数据（用于删除对应图片）
    const deletedAlbum = albums.albums[albumIndex];
    
    // 从数组中删除相册
    albums.albums.splice(albumIndex, 1);
    
    // 保存更新后的数据
    if (writeJsonFile('albums.json', albums)) {
      // 尝试删除相册封面图片和内部照片
      try {
        if (deletedAlbum.cover) {
          const coverPath = path.join(__dirname, deletedAlbum.cover);
          if (fs.existsSync(coverPath)) {
            fs.unlinkSync(coverPath);
          }
        }
        
        // 删除相册中的所有照片
        if (deletedAlbum.photos && Array.isArray(deletedAlbum.photos)) {
          deletedAlbum.photos.forEach(photo => {
            if (photo.src) {
              const photoPath = path.join(__dirname, photo.src);
              if (fs.existsSync(photoPath)) {
                fs.unlinkSync(photoPath);
              }
            }
          });
        }
      } catch (err) {
        console.error('删除相册图片文件时出错:', err);
        // 继续执行，不影响API响应
      }
      
      return res.json({ success: true, message: '相册已成功删除' });
    } else {
      return res.status(500).json({ success: false, message: '保存相册数据失败' });
    }
  } catch (error) {
    console.error('删除相册出错:', error);
    return res.status(500).json({ success: false, message: '删除相册失败', error: error.message });
  }
});

// 添加日志接口
app.post('/api/diary/add', (req, res) => {
  try {
    const diaryData = req.body;
    if (!diaryData || !diaryData.title || !diaryData.date || !diaryData.author) {
      return res.status(400).json({ success: false, message: '缺少必要的日志信息' });
    }

    // 读取日志数据
    const diary = readJsonFile('diary.json');
    if (!diary) {
      return res.status(500).json({ success: false, message: '无法读取日志数据' });
    }

    // 生成新ID
    const maxId = Math.max(...diary.entries.map(entry => entry.id || 0), 0);
    diaryData.id = maxId + 1;
    
    // 确保必要属性存在
    if (!diaryData.photos) diaryData.photos = [];
    if (!diaryData.likes) diaryData.likes = 0;
    if (!diaryData.comments) diaryData.comments = [];
    
    // 将新日志添加到数据中
    diary.entries.push(diaryData);
    
    // 保存更新后的数据
    if (writeJsonFile('diary.json', diary)) {
      return res.json({ success: true, diary: diaryData });
    } else {
      return res.status(500).json({ success: false, message: '保存日志数据失败' });
    }
  } catch (error) {
    console.error('添加日志出错:', error);
    return res.status(500).json({ success: false, message: '添加日志失败', error: error.message });
  }
});

// 删除日志接口
app.delete('/api/diary/:id', (req, res) => {
  try {
    const diaryId = parseInt(req.params.id);
    if (isNaN(diaryId)) {
      return res.status(400).json({ success: false, message: '无效的日志ID' });
    }

    // 读取日志数据
    const diary = readJsonFile('diary.json');
    if (!diary) {
      return res.status(500).json({ success: false, message: '无法读取日志数据' });
    }

    // 查找要删除的日志
    const entryIndex = diary.entries.findIndex(entry => entry.id === diaryId);
    if (entryIndex === -1) {
      return res.status(404).json({ success: false, message: '日志不存在' });
    }

    // 获取要删除的日志数据（用于删除对应图片）
    const deletedEntry = diary.entries[entryIndex];
    
    // 从数组中删除日志
    diary.entries.splice(entryIndex, 1);
    
    // 保存更新后的数据
    if (writeJsonFile('diary.json', diary)) {
      // 尝试删除日志中的照片
      try {
        if (deletedEntry.photos && Array.isArray(deletedEntry.photos)) {
          deletedEntry.photos.forEach(photo => {
            if (photo.src) {
              const photoPath = path.join(__dirname, photo.src);
              if (fs.existsSync(photoPath)) {
                fs.unlinkSync(photoPath);
              }
            }
          });
        }
      } catch (err) {
        console.error('删除日志图片文件时出错:', err);
        // 继续执行，不影响API响应
      }
      
      return res.json({ success: true, message: '日志已成功删除' });
    } else {
      return res.status(500).json({ success: false, message: '保存日志数据失败' });
    }
  } catch (error) {
    console.error('删除日志出错:', error);
    return res.status(500).json({ success: false, message: '删除日志失败', error: error.message });
  }
});

// 添加纪念日接口
app.post('/api/memory/add', (req, res) => {
  try {
    const memoryData = req.body;
    if (!memoryData || !memoryData.title || !memoryData.date || !memoryData.type) {
      return res.status(400).json({ success: false, message: '缺少必要的纪念日信息' });
    }

    // 读取纪念日数据
    const memory = readJsonFile('memory.json');
    if (!memory) {
      return res.status(500).json({ success: false, message: '无法读取纪念日数据' });
    }

    // 生成新ID
    const maxId = Math.max(
      ...memory.memories.map(mem => mem.id || 0),
      ...memory.upcomingEvents.map(event => event.id || 0),
      0
    );
    memoryData.id = maxId + 1;
    
    // 确保必要属性存在
    if (!memoryData.photos) memoryData.photos = [];
    if (!memoryData.tags) memoryData.tags = [];
    if (memoryData.isSpecial === undefined) memoryData.isSpecial = false;
    
    // 根据日期确定是添加到回忆还是即将到来的事件
    const today = new Date();
    const memoryDate = new Date(memoryData.date);
    
    if (memoryDate <= today) {
      // 过去的日期，添加到memories数组
      memory.memories.push(memoryData);
    } else {
      // 未来的日期，添加到upcomingEvents数组
      // 简化对象，只保留必要的字段
      const upcomingEvent = {
        id: memoryData.id,
        date: memoryData.date,
        title: memoryData.title,
        type: memoryData.type
      };
      memory.upcomingEvents.push(upcomingEvent);
    }
    
    // 保存更新后的数据
    if (writeJsonFile('memory.json', memory)) {
      return res.json({ success: true, memory: memoryData });
    } else {
      return res.status(500).json({ success: false, message: '保存纪念日数据失败' });
    }
  } catch (error) {
    console.error('添加纪念日出错:', error);
    return res.status(500).json({ success: false, message: '添加纪念日失败', error: error.message });
  }
});

// 删除纪念日接口
app.delete('/api/memory/:id', (req, res) => {
  try {
    const memoryId = parseInt(req.params.id);
    if (isNaN(memoryId)) {
      return res.status(400).json({ success: false, message: '无效的纪念日ID' });
    }

    // 读取纪念日数据
    const memory = readJsonFile('memory.json');
    if (!memory) {
      return res.status(500).json({ success: false, message: '无法读取纪念日数据' });
    }

    // 在memories数组中查找要删除的纪念日
    let deletedMemory = null;
    let isMemory = true;
    
    const memoryIndex = memory.memories.findIndex(mem => mem.id === memoryId);
    if (memoryIndex !== -1) {
      deletedMemory = memory.memories[memoryIndex];
      memory.memories.splice(memoryIndex, 1);
    } else {
      // 在upcomingEvents数组中查找
      const eventIndex = memory.upcomingEvents.findIndex(event => event.id === memoryId);
      if (eventIndex !== -1) {
        deletedMemory = memory.upcomingEvents[eventIndex];
        memory.upcomingEvents.splice(eventIndex, 1);
        isMemory = false;
      } else {
        return res.status(404).json({ success: false, message: '纪念日不存在' });
      }
    }
    
    // 保存更新后的数据
    if (writeJsonFile('memory.json', memory)) {
      // 尝试删除纪念日中的照片（仅对过去的纪念日）
      if (isMemory && deletedMemory) {
        try {
          if (deletedMemory.photos && Array.isArray(deletedMemory.photos)) {
            deletedMemory.photos.forEach(photo => {
              if (photo.src) {
                const photoPath = path.join(__dirname, photo.src);
                if (fs.existsSync(photoPath)) {
                  fs.unlinkSync(photoPath);
                }
              }
            });
          }
        } catch (err) {
          console.error('删除纪念日图片文件时出错:', err);
          // 继续执行，不影响API响应
        }
      }
      
      return res.json({ success: true, message: '纪念日已成功删除' });
    } else {
      return res.status(500).json({ success: false, message: '保存纪念日数据失败' });
    }
  } catch (error) {
    console.error('删除纪念日出错:', error);
    return res.status(500).json({ success: false, message: '删除纪念日失败', error: error.message });
  }
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`服务器运行在 http://localhost:${PORT}`);
}); 